import Noty from 'noty';

export default {
  createNoty(text, type, ...rest) {
    if (rest.length > 0) {
      return new Noty({
        text,
        layout: 'topRight',
        theme: 'relax',
        type,
        timeout: 3000,
        ...rest[0],
      }).show();
    }
    return new Noty({
      text,
      layout: 'topRight',
      theme: 'relax',
      type,
      timeout: 3000,
    }).show();
  },
  getAppName() {
    const queryList = window.location.search.substr(1).split('&');
    const nameQuery = queryList.filter(query => query.startsWith('ObjectId'));
    if (nameQuery[0]) {
      return nameQuery[0].split('=')[1];
    }
    // console.log(queryList);
    return false;
  },
  testEmail(string) {
    const reg = /^\w+((-\w+)|(\.\w+))*@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/;
    return reg.test(string);
  },
  /* eslint-disable */

  /*
  * 获得时间差,时间格式为 年-月-日 小时:分钟:秒 或者 年/月/日 小时：分钟：秒
  * 其中，年月日为全格式，例如 ： 2010-10-12 01:00:00
  * 返回精度为：秒，分，小时，天
  */

  getDateDiff(startTime, endTime, diffType) {
    // 将xxxx-xx-xx的时间格式，转换为 xxxx/xx/xx 的格式
    const tempStartTime = startTime.replace(/\-/g, '/');
    const tempEndTime = endTime.replace(/\-/g, '/');
    // 将计算间隔类性字符转换为小写
    const tempDiffType = diffType.toLowerCase();
    const sTime = new Date(tempStartTime);  // 开始时间
    const eTime = new Date(tempEndTime);  // 结束时间
    // 作为除数的数字
    let divNum = 1;
    switch (tempDiffType) {
      case 'second':
        divNum = 1000;
        break;
      case 'minute':
        divNum = 1000 * 60;
        break;
      case 'hour':
        divNum = 1000 * 3600;
        break;
      case 'day':
        divNum = 1000 * 3600 * 24;
        break;
      default:
        break;
    }
    return parseInt((eTime.getTime() - sTime.getTime()) / parseInt(divNum, 10), 10);
  },
  //  \const testStr = testDate.format("yyyy-MM-dd hh:mm:ss");
  /**
   * 文件大小单位转换
   * 不足 1K 的以 B 为单位
   * 不足 1M 的以 K 为单位
   * 依次类推
   *
   * 不合法的输入值或单位将返回  '-'
   *
   * @param {String|Number} num - 转换前的数量
   * @param {string} unit - 输入值的单位
   */
  formatSize(num, unit, hodor) {
    const DEFAULT_STR = hodor || '-';
    const PRECISION = 1;
    const units = ['B', 'K', 'M', 'G', 'T', 'P'];
    if (typeof unit !== 'string') return DEFAULT_STR;
    if (units.indexOf(unit.toUpperCase()) < 0) return DEFAULT_STR;
    if (isNaN(parseFloat(num)) || !isFinite(num)) return DEFAULT_STR;

    if (unit.toUpperCase() === 'B' && num < 1024 ||
      unit.toUpperCase() === 'P' && num >= 1) {
      return `${num}${unit.toUpperCase()}`;
    }

    const inputUnintIndex = units.indexOf(unit.toUpperCase());

    if (num >= 1) {
      const relIndex = Math.floor(Math.log(num) / Math.log(1024));
      const number = (num / Math.pow(1024, Math.floor(relIndex))).toFixed(PRECISION);
      const outputUnit = units[relIndex + inputUnintIndex];
      return `${number}${outputUnit}`;
    }
    const number = (num * 1024).toFixed(PRECISION);
    const outputUnit = units[inputUnintIndex - 1];
    return `${number}${outputUnit}`;
  },

  formatNum(num, bit) {
    const test = parseInt(num, 10);
    const testBit = parseInt(bit, 10);
    if (Number.isNaN(test)) return '-';

    return Math.round(num * (testBit * 10))/(testBit * 10);
  },
};
